// ============================================
// 21 - 高级特性 (Advanced Features)
// ============================================

/// Rust 的高级特性包括不安全代码、高级 trait、类型和宏

// ==================== 不安全 Rust ====================

/// 不安全 Rust
pub fn unsafe_rust() {
    println!("\n=== 不安全 Rust ===");
    
    println!("不安全超能力:");
    println!("1. 解引用裸指针");
    println!("2. 调用不安全函数或方法");
    println!("3. 访问或修改可变静态变量");
    println!("4. 实现不安全 trait");
    println!("5. 访问 union 的字段");
}

/// 裸指针
pub fn raw_pointers() {
    println!("\n=== 裸指针 ===");
    
    let mut num = 5;
    
    // 创建裸指针（安全）
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;
    
    // 解引用裸指针（不安全）
    unsafe {
        println!("r1: {}", *r1);
        println!("r2: {}", *r2);
    }
    
    // 裸指针可以是可变或不可变的
    // 可以同时存在多个指向同一位置的裸指针
}

/// 不安全函数
unsafe fn dangerous() {
    println!("这是一个不安全函数");
}

pub fn unsafe_functions() {
    println!("\n=== 不安全函数 ===");
    
    unsafe {
        dangerous();
    }
}

/// 创建不安全代码的安全抽象
fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();
    let ptr = values.as_mut_ptr();
    
    assert!(mid <= len);
    
    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

pub fn safe_abstraction() {
    println!("\n=== 安全抽象 ===");
    
    let mut v = vec![1, 2, 3, 4, 5, 6];
    let (left, right) = split_at_mut(&mut v, 3);
    
    println!("左边: {:?}", left);
    println!("右边: {:?}", right);
}

/// extern 函数
unsafe extern "C" {
    fn abs(input: i32) -> i32;
}

pub fn extern_functions() {
    println!("\n=== extern 函数 ===");
    
    unsafe {
        println!("C abs(-3) = {}", abs(-3));
    }
}

/// 静态变量
static HELLO_WORLD: &str = "Hello, world!";
static mut COUNTER: u32 = 0;

pub fn static_variables() {
    println!("\n=== 静态变量 ===");
    
    println!("不可变静态: {}", HELLO_WORLD);
    
    unsafe {
        COUNTER += 1;
        println!("可变静态: {}", std::ptr::addr_of!(COUNTER).read());
    }
}

/// 不安全 trait
unsafe trait Foo {
    // 方法
}

unsafe impl Foo for i32 {
    // 实现
}

pub fn unsafe_traits() {
    println!("\n=== 不安全 Trait ===");
    println!("当 trait 的实现可能违反内存安全时使用");
}

// ==================== 高级 Trait ====================

/// 关联类型
pub trait Iterator2 {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

pub fn associated_types() {
    println!("\n=== 关联类型 ===");
    println!("关联类型在 trait 定义中指定占位符类型");
}

/// 默认泛型类型参数和运算符重载
use std::ops::Add;

#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;
    
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

pub fn operator_overloading() {
    println!("\n=== 运算符重载 ===");
    
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let p3 = p1 + p2;
    
    println!("{:?} + {:?} = {:?}", p1, p2, p3);
}

/// 完全限定语法
trait Pilot {
    fn fly(&self);
}

trait Wizard {
    fn fly(&self);
}

struct Human;

impl Pilot for Human {
    fn fly(&self) {
        println!("这是机长广播");
    }
}

impl Wizard for Human {
    fn fly(&self) {
        println!("起飞!");
    }
}

impl Human {
    fn fly(&self) {
        println!("*疯狂挥舞手臂*");
    }
}

pub fn fully_qualified_syntax() {
    println!("\n=== 完全限定语法 ===");
    
    let person = Human;
    
    Pilot::fly(&person);
    Wizard::fly(&person);
    person.fly();
}

/// 父 trait
use std::fmt;

trait OutlinePrint: fmt::Display {
    fn outline_print(&self) {
        let output = self.to_string();
        let len = output.len();
        println!("{}", "*".repeat(len + 4));
        println!("*{}*", " ".repeat(len + 2));
        println!("* {} *", output);
        println!("*{}*", " ".repeat(len + 2));
        println!("{}", "*".repeat(len + 4));
    }
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl OutlinePrint for Point {}

pub fn super_traits() {
    println!("\n=== 父 Trait ===");
    
    let p = Point { x: 1, y: 3 };
    p.outline_print();
}

/// newtype 模式
struct Wrapper(Vec<String>);

impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{}]", self.0.join(", "))
    }
}

pub fn newtype_pattern() {
    println!("\n=== Newtype 模式 ===");
    
    let w = Wrapper(vec![
        String::from("hello"),
        String::from("world"),
    ]);
    
    println!("w = {}", w);
}

// ==================== 高级类型 ====================

/// 类型别名
type Kilometers = i32;
type Thunk = Box<dyn Fn() + Send + 'static>;

pub fn type_aliases() {
    println!("\n=== 类型别名 ===");
    
    let x: i32 = 5;
    let y: Kilometers = 5;
    
    println!("x + y = {}", x + y);
    
    let _f: Thunk = Box::new(|| println!("hi"));
}

/// Never 类型
pub fn never_type() {
    println!("\n=== Never 类型 ===");
    
    println!("! 类型表示永不返回");
    println!("用于: panic!, continue, loop, 等");
    
    fn bar() -> ! {
        panic!("这个函数永不返回");
    }
    
    let _f = bar;
}

/// 动态大小类型 (DST)
pub fn dynamically_sized_types() {
    println!("\n=== 动态大小类型 ===");
    
    println!("DST 或 unsized types:");
    println!("- str (不是 &str)");
    println!("- trait 对象");
    println!("- 切片");
    
    println!("\nRust 需要知道类型的大小");
    println!("DST 必须放在指针后面: &str, Box<dyn Trait>");
}

// ==================== 高级函数与闭包 ====================

/// 函数指针
fn add_one(x: i32) -> i32 {
    x + 1
}

fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
    f(arg) + f(arg)
}

pub fn function_pointers() {
    println!("\n=== 函数指针 ===");
    
    let answer = do_twice(add_one, 5);
    println!("结果: {}", answer);
    
    // 函数指针实现了所有三个闭包 trait
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> = list_of_numbers
        .iter()
        .map(ToString::to_string)
        .collect();
    
    println!("字符串列表: {:?}", list_of_strings);
}

/// 返回闭包
pub fn returning_closures() {
    println!("\n=== 返回闭包 ===");
    
    fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
        Box::new(|x| x + 1)
    }
    
    let f = returns_closure();
    println!("f(5) = {}", f(5));
}

// ==================== 宏 ====================

/// 声明宏
pub fn declarative_macros() {
    println!("\n=== 声明宏 ===");
    
    // 使用 macro_rules! 定义宏
    macro_rules! my_vec {
        ( $( $x:expr ),* ) => {
            {
                let mut temp_vec = Vec::new();
                $(
                    temp_vec.push($x);
                )*
                temp_vec
            }
        };
    }
    
    let v = my_vec![1, 2, 3];
    println!("向量: {:?}", v);
}

/// 过程宏
pub fn procedural_macros() {
    println!("\n=== 过程宏 ===");
    
    println!("过程宏类型:");
    println!("1. 自定义 #[derive] 宏");
    println!("2. 属性宏");
    println!("3. 函数宏");
    
    println!("\n示例:");
    println!("#[derive(HelloMacro)]");
    println!("struct Pancakes;");
}

/// 宏最佳实践
pub fn macro_best_practices() {
    println!("\n=== 宏最佳实践 ===");
    
    println!("1. 优先使用函数而非宏");
    println!("2. 宏难以调试和维护");
    println!("3. 宏可以接受可变数量的参数");
    println!("4. 宏在编译时展开");
    println!("5. 宏可以生成代码");
    println!("6. 注意宏的卫生性");
}

// ==================== 其他高级特性 ====================

/// 内联汇编
pub fn inline_assembly() {
    println!("\n=== 内联汇编 ===");
    println!("使用 asm! 宏编写内联汇编");
    println!("需要 nightly Rust");
}

/// 链接
pub fn linking() {
    println!("\n=== 链接 ===");
    println!("使用 #[link] 属性链接外部库");
    println!("#[link(name = \"foo\")]");
}

/// 全局分配器
pub fn global_allocator() {
    println!("\n=== 全局分配器 ===");
    println!("使用 #[global_allocator] 自定义内存分配器");
}

/// 特性标志
pub fn feature_flags() {
    println!("\n=== 特性标志 ===");
    println!("在 Cargo.toml 中定义特性:");
    println!("[features]");
    println!("default = []");
    println!("advanced = []");
    
    println!("\n在代码中使用:");
    println!("#[cfg(feature = \"advanced\")]");
}

/// 条件编译
pub fn conditional_compilation() {
    println!("\n=== 条件编译 ===");
    
    #[cfg(target_os = "linux")]
    println!("在 Linux 上");
    
    #[cfg(target_os = "macos")]
    println!("在 macOS 上");
    
    #[cfg(target_os = "windows")]
    println!("在 Windows 上");
    
    #[cfg(test)]
    println!("测试模式");
    
    #[cfg(debug_assertions)]
    println!("调试模式");
}

/// 属性
pub fn attributes() {
    println!("\n=== 属性 ===");
    
    println!("常用属性:");
    println!("- #[derive(...)] - 自动实现 trait");
    println!("- #[allow(...)] - 允许警告");
    println!("- #[warn(...)] - 警告");
    println!("- #[deny(...)] - 错误");
    println!("- #[test] - 测试函数");
    println!("- #[cfg(...)] - 条件编译");
    println!("- #[inline] - 内联建议");
}

// ==================== 高级特性最佳实践 ====================

/// 高级特性最佳实践
pub fn advanced_best_practices() {
    println!("\n=== 高级特性最佳实践 ===");
    
    println!("不安全代码:");
    println!("1. 最小化 unsafe 块");
    println!("2. 在 unsafe 块周围提供安全抽象");
    println!("3. 仔细文档化不安全代码的不变量");
    println!("4. 彻底测试不安全代码");
    
    println!("\n宏:");
    println!("1. 保持宏简单");
    println!("2. 提供良好的错误消息");
    println!("3. 考虑使用函数代替");
    
    println!("\n其他:");
    println!("1. 理解类型系统的限制");
    println!("2. 使用 newtype 模式增强类型安全");
    println!("3. 合理使用条件编译");
}

/// 主函数 - 演示所有功能
#[allow(dead_code)]
pub fn main() {
    println!("╔════════════════════════════════════════╗");
    println!("║   Rust 高级特性教程                    ║");
    println!("╚════════════════════════════════════════╝");
    
    unsafe_rust();
    raw_pointers();
    unsafe_functions();
    safe_abstraction();
    extern_functions();
    static_variables();
    unsafe_traits();
    
    associated_types();
    operator_overloading();
    fully_qualified_syntax();
    super_traits();
    newtype_pattern();
    
    type_aliases();
    never_type();
    dynamically_sized_types();
    
    function_pointers();
    returning_closures();
    
    declarative_macros();
    procedural_macros();
    macro_best_practices();
    
    inline_assembly();
    linking();
    global_allocator();
    feature_flags();
    conditional_compilation();
    attributes();
    
    advanced_best_practices();
    
    println!("\n✅ 高级特性教程完成！");
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_point_add() {
        let p1 = Point { x: 1, y: 2 };
        let p2 = Point { x: 3, y: 4 };
        let p3 = p1 + p2;
        assert_eq!(p3, Point { x: 4, y: 6 });
    }
    
    #[test]
    fn test_type_alias() {
        let x: Kilometers = 5;
        assert_eq!(x, 5);
    }
}

